home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Modules / stdwinmodule.c < prev    next >
Text File  |  1995-12-21  |  52KB  |  2,652 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* Stdwin module */
  26.  
  27. /* Stdwin itself is a module, not a separate object type.
  28.    Object types defined here:
  29.     wp: a window
  30.     dp: a drawing structure (only one can exist at a time)
  31.     mp: a menu
  32.     tp: a textedit block
  33.     bp: a bitmap
  34. */
  35.  
  36. /* Rules for translating C stdwin function calls into Python stwin:
  37.    - All names drop their initial letter 'w'
  38.    - Functions with a window as first parameter are methods of window objects
  39.    - There is no equivalent for wclose(); just delete the window object
  40.      (all references to it!)  (XXX maybe this is a bad idea)
  41.    - w.begindrawing() returns a drawing object
  42.    - There is no equivalent for wenddrawing(win); just delete the drawing
  43.       object (all references to it!)  (XXX maybe this is a bad idea)
  44.    - Functions that may only be used inside wbegindrawing / wendddrawing
  45.      are methods of the drawing object; this includes the text measurement
  46.      functions (which however have doubles as module functions).
  47.    - Methods of the drawing object drop an initial 'draw' from their name
  48.      if they have it, e.g., wdrawline() --> d.line()
  49.    - The obvious type conversions: int --> intobject; string --> stringobject
  50.    - A text parameter followed by a length parameter is only a text (string)
  51.      parameter in Python
  52.    - A point or other pair of horizontal and vertical coordinates is always
  53.      a pair of integers in Python
  54.    - Two points forming a rectangle or endpoints of a line segment are a
  55.      pair of points in Python
  56.    - The arguments to d.elarc() are three points.
  57.    - The functions wgetclip() and wsetclip() are translated into
  58.      stdwin.getcutbuffer() and stdwin.setcutbuffer(); 'clip' is really
  59.      a bad word for what these functions do (clipping has a different
  60.      meaning in the drawing world), while cutbuffer is standard X jargon.
  61.      XXX This must change again in the light of changes to stdwin!
  62.    - For textedit, similar rules hold, but they are less strict.
  63.    XXX more?
  64. */
  65.  
  66. #include "allobjects.h"
  67. #include "modsupport.h"
  68. #include "ceval.h"
  69. #include "sysmodule.h"
  70. #ifdef macintosh
  71. #include "macglue.h"
  72. #endif
  73.  
  74. #ifdef macintosh
  75. #include ":::stdwin:H:stdwin.h"
  76. #else /* !macintosh */
  77. #include "stdwin.h"
  78. #define HAVE_BITMAPS
  79. #endif /* !macintosh */
  80.  
  81. #ifdef WITH_THREAD
  82.  
  83. #include "thread.h"
  84.  
  85. static type_lock StdwinLock; /* Lock held when interpreter not locked */
  86.  
  87. #define BGN_STDWIN BGN_SAVE acquire_lock(StdwinLock, 1);
  88. #define RET_STDWIN release_lock(StdwinLock); RET_SAVE
  89. #define END_STDWIN release_lock(StdwinLock); END_SAVE
  90.  
  91. #else
  92.  
  93. #define BGN_STDWIN BGN_SAVE
  94. #define RET_STDWIN RET_SAVE
  95. #define END_STDWIN END_SAVE
  96.  
  97. #endif
  98.  
  99. #define getpointarg(v, a) getargs(v, "(ii)", a, (a)+1)
  100. #define get3pointarg(v, a) getargs(v, "((ii)(ii)(ii))", \
  101.                 a, a+1, a+2, a+3, a+4, a+5)
  102. #define getrectarg(v, a) getargs(v, "((ii)(ii))", a, a+1, a+2, a+3)
  103. #define getrectintarg(v, a) getargs(v, "(((ii)(ii))i)", a, a+1, a+2, a+3, a+4)
  104. #define getpointintarg(v, a) getargs(v, "((ii)i)", a, a+1, a+2)
  105. #define getrectpointarg(v, a) getargs(v, "(((ii)(ii))(ii))", \
  106.                 a, a+1, a+2, a+3, a+4, a+5)
  107.  
  108. static object *StdwinError; /* Exception stdwin.error */
  109.  
  110. /* Window and menu object types declared here because of forward references */
  111.  
  112. typedef struct {
  113.     OB_HEAD
  114.     object    *w_title;
  115.     WINDOW    *w_win;
  116.     object    *w_attr;    /* Attributes dictionary */
  117. } windowobject;
  118.  
  119. staticforward typeobject Windowtype;
  120.  
  121. #define is_windowobject(wp) ((wp)->ob_type == &Windowtype)
  122.  
  123. typedef struct {
  124.     OB_HEAD
  125.     MENU    *m_menu;
  126.     int     m_id;
  127.     object    *m_attr;    /* Attributes dictionary */
  128. } menuobject;
  129.  
  130. staticforward typeobject Menutype;
  131.  
  132. #define is_menuobject(mp) ((mp)->ob_type == &Menutype)
  133.  
  134. typedef struct {
  135.     OB_HEAD
  136.     BITMAP    *b_bitmap;
  137.     object    *b_attr;    /* Attributes dictionary */
  138. } bitmapobject;
  139.  
  140. staticforward typeobject Bitmaptype;
  141.  
  142. #define is_bitmapobject(mp) ((mp)->ob_type == &Bitmaptype)
  143.  
  144.  
  145. /* Strongly stdwin-specific argument handlers */
  146.  
  147. static int
  148. getmenudetail(v, ep)
  149.     object *v;
  150.     EVENT *ep;
  151. {
  152.     menuobject *mp;
  153.     if (!getargs(v, "(Oi)", &mp, &ep->u.m.item))
  154.         return 0;
  155.     if (!is_menuobject(mp))
  156.         return err_badarg();
  157.     ep->u.m.id = mp->m_id;
  158.     return 1;
  159. }
  160.  
  161. static int
  162. geteventarg(v, ep)
  163.     object *v;
  164.     EVENT *ep;
  165. {
  166.     object *wp, *detail;
  167.     int a[4];
  168.     if (!getargs(v, "(iOO)", &ep->type, &wp, &detail))
  169.         return 0;
  170.     if (is_windowobject(wp))
  171.         ep->window = ((windowobject *)wp) -> w_win;
  172.     else if (wp == None)
  173.         ep->window = NULL;
  174.     else
  175.         return err_badarg();
  176.     switch (ep->type) {
  177.     case WE_CHAR: {
  178.             char c;
  179.             if (!getargs(detail, "c", &c))
  180.                 return 0;
  181.             ep->u.character = c;
  182.             return 1;
  183.         }
  184.     case WE_COMMAND:
  185.         return getintarg(detail, &ep->u.command);
  186.     case WE_DRAW:
  187.         if (!getrectarg(detail, a))
  188.             return 0;
  189.         ep->u.area.left = a[0];
  190.         ep->u.area.top = a[1];
  191.         ep->u.area.right = a[2];
  192.         ep->u.area.bottom = a[3];
  193.         return 1;
  194.     case WE_MOUSE_DOWN:
  195.     case WE_MOUSE_UP:
  196.     case WE_MOUSE_MOVE:
  197.         return getargs(detail, "((ii)iii)",
  198.                 &ep->u.where.h, &ep->u.where.v,
  199.                 &ep->u.where.clicks,
  200.                 &ep->u.where.button,
  201.                 &ep->u.where.mask);
  202.     case WE_MENU:
  203.         return getmenudetail(detail, ep);
  204.     case WE_KEY:
  205.         return getargs(detail, "(ii)",
  206.                    &ep->u.key.code, &ep->u.key.mask);
  207.     default:
  208.         return 1;
  209.     }
  210. }
  211.  
  212.  
  213. /* Return construction tools */
  214.  
  215. static object *
  216. makepoint(a, b)
  217.     int a, b;
  218. {
  219.     return mkvalue("(ii)", a, b);
  220. }
  221.  
  222. static object *
  223. makerect(a, b, c, d)
  224.     int a, b, c, d;
  225. {
  226.     return mkvalue("((ii)(ii))", a, b, c, d);
  227. }
  228.  
  229.  
  230. /* Drawing objects */
  231.  
  232. typedef struct {
  233.     OB_HEAD
  234.     windowobject    *d_ref;
  235. } drawingobject;
  236.  
  237. static drawingobject *Drawing; /* Set to current drawing object, or NULL */
  238.  
  239. /* Drawing methods */
  240.  
  241. static object *
  242. drawing_close(dp)
  243.     drawingobject *dp;
  244. {
  245.     if (dp->d_ref != NULL) {
  246.         wenddrawing(dp->d_ref->w_win);
  247.         Drawing = NULL;
  248.         DECREF(dp->d_ref);
  249.         dp->d_ref = NULL;
  250.     }
  251.     INCREF(None);
  252.     return None;
  253. }
  254.  
  255. static void
  256. drawing_dealloc(dp)
  257.     drawingobject *dp;
  258. {
  259.     if (dp->d_ref != NULL) {
  260.         wenddrawing(dp->d_ref->w_win);
  261.         Drawing = NULL;
  262.         DECREF(dp->d_ref);
  263.         dp->d_ref = NULL;
  264.     }
  265.     free((char *)dp);
  266. }
  267.  
  268. static object *
  269. drawing_generic(dp, args, func)
  270.     drawingobject *dp;
  271.     object *args;
  272.     void (*func) FPROTO((int, int, int, int));
  273. {
  274.     int a[4];
  275.     if (!getrectarg(args, a))
  276.         return NULL;
  277.     (*func)(a[0], a[1], a[2], a[3]);
  278.     INCREF(None);
  279.     return None;
  280. }
  281.  
  282. static object *
  283. drawing_line(dp, args)
  284.     drawingobject *dp;
  285.     object *args;
  286. {
  287.     return drawing_generic(dp, args, wdrawline);
  288. }
  289.  
  290. static object *
  291. drawing_xorline(dp, args)
  292.     drawingobject *dp;
  293.     object *args;
  294. {
  295.     return drawing_generic(dp, args, wxorline);
  296. }
  297.  
  298. static object *
  299. drawing_circle(dp, args)
  300.     drawingobject *dp;
  301.     object *args;
  302. {
  303.     int a[3];
  304.     if (!getpointintarg(args, a))
  305.         return NULL;
  306.     wdrawcircle(a[0], a[1], a[2]);
  307.     INCREF(None);
  308.     return None;
  309. }
  310.  
  311. static object *
  312. drawing_fillcircle(dp, args)
  313.     drawingobject *dp;
  314.     object *args;
  315. {
  316.     int a[3];
  317.     if (!getpointintarg(args, a))
  318.         return NULL;
  319.     wfillcircle(a[0], a[1], a[2]);
  320.     INCREF(None);
  321.     return None;
  322. }
  323.  
  324. static object *
  325. drawing_xorcircle(dp, args)
  326.     drawingobject *dp;
  327.     object *args;
  328. {
  329.     int a[3];
  330.     if (!getpointintarg(args, a))
  331.         return NULL;
  332.     wxorcircle(a[0], a[1], a[2]);
  333.     INCREF(None);
  334.     return None;
  335. }
  336.  
  337. static object *
  338. drawing_elarc(dp, args)
  339.     drawingobject *dp;
  340.     object *args;
  341. {
  342.     int a[6];
  343.     if (!get3pointarg(args, a))
  344.         return NULL;
  345.     wdrawelarc(a[0], a[1], a[2], a[3], a[4], a[5]);
  346.     INCREF(None);
  347.     return None;
  348. }
  349.  
  350. static object *
  351. drawing_fillelarc(dp, args)
  352.     drawingobject *dp;
  353.     object *args;
  354. {
  355.     int a[6];
  356.     if (!get3pointarg(args, a))
  357.         return NULL;
  358.     wfillelarc(a[0], a[1], a[2], a[3], a[4], a[5]);
  359.     INCREF(None);
  360.     return None;
  361. }
  362.  
  363. static object *
  364. drawing_xorelarc(dp, args)
  365.     drawingobject *dp;
  366.     object *args;
  367. {
  368.     int a[6];
  369.     if (!get3pointarg(args, a))
  370.         return NULL;
  371.     wxorelarc(a[0], a[1], a[2], a[3], a[4], a[5]);
  372.     INCREF(None);
  373.     return None;
  374. }
  375.  
  376. static object *
  377. drawing_box(dp, args)
  378.     drawingobject *dp;
  379.     object *args;
  380. {
  381.     return drawing_generic(dp, args, wdrawbox);
  382. }
  383.  
  384. static object *
  385. drawing_erase(dp, args)
  386.     drawingobject *dp;
  387.     object *args;
  388. {
  389.     return drawing_generic(dp, args, werase);
  390. }
  391.  
  392. static object *
  393. drawing_paint(dp, args)
  394.     drawingobject *dp;
  395.     object *args;
  396. {
  397.     return drawing_generic(dp, args, wpaint);
  398. }
  399.  
  400. static object *
  401. drawing_invert(dp, args)
  402.     drawingobject *dp;
  403.     object *args;
  404. {
  405.     return drawing_generic(dp, args, winvert);
  406. }
  407.  
  408. static POINT *
  409. getpointsarray(v, psize)
  410.     object *v;
  411.     int *psize;
  412. {
  413.     int n = -1;
  414.     object * (*getitem) PROTO((object *, int));
  415.     int i;
  416.     POINT *points;
  417.  
  418.     if (v == NULL)
  419.         ;
  420.     else if (is_listobject(v)) {
  421.         n = getlistsize(v);
  422.         getitem = getlistitem;
  423.     }
  424.     else if (is_tupleobject(v)) {
  425.         n = gettuplesize(v);
  426.         getitem = gettupleitem;
  427.     }
  428.  
  429.     if (n <= 0) {
  430.         (void) err_badarg();
  431.         return NULL;
  432.     }
  433.  
  434.     points = NEW(POINT, n);
  435.     if (points == NULL) {
  436.         (void) err_nomem();
  437.         return NULL;
  438.     }
  439.  
  440.     for (i = 0; i < n; i++) {
  441.         object *w = (*getitem)(v, i);
  442.         int a[2];
  443.         if (!getpointarg(w, a)) {
  444.             DEL(points);
  445.             return NULL;
  446.         }
  447.         points[i].h = a[0];
  448.         points[i].v = a[1];
  449.     }
  450.  
  451.     *psize = n;
  452.     return points;
  453. }
  454.  
  455. static object *
  456. drawing_poly(dp, args)
  457.     drawingobject *dp;
  458.     object *args;
  459. {
  460.     int n;
  461.     POINT *points = getpointsarray(args, &n);
  462.     if (points == NULL)
  463.         return NULL;
  464.     wdrawpoly(n, points);
  465.     DEL(points);
  466.     INCREF(None);
  467.     return None;
  468. }
  469.  
  470. static object *
  471. drawing_fillpoly(dp, args)
  472.     drawingobject *dp;
  473.     object *args;
  474. {
  475.     int n;
  476.     POINT *points = getpointsarray(args, &n);
  477.     if (points == NULL)
  478.         return NULL;
  479.     wfillpoly(n, points);
  480.     DEL(points);
  481.     INCREF(None);
  482.     return None;
  483. }
  484.  
  485. static object *
  486. drawing_xorpoly(dp, args)
  487.     drawingobject *dp;
  488.     object *args;
  489. {
  490.     int n;
  491.     POINT *points = getpointsarray(args, &n);
  492.     if (points == NULL)
  493.         return NULL;
  494.     wxorpoly(n, points);
  495.     DEL(points);
  496.     INCREF(None);
  497.     return None;
  498. }
  499.  
  500. static object *
  501. drawing_cliprect(dp, args)
  502.     drawingobject *dp;
  503.     object *args;
  504. {
  505.     return drawing_generic(dp, args, wcliprect);
  506. }
  507.  
  508. static object *
  509. drawing_noclip(dp, args)
  510.     drawingobject *dp;
  511.     object *args;
  512. {
  513.     if (!getnoarg(args))
  514.         return NULL;
  515.     wnoclip();
  516.     INCREF(None);
  517.     return None;
  518. }
  519.  
  520. static object *
  521. drawing_shade(dp, args)
  522.     drawingobject *dp;
  523.     object *args;
  524. {
  525.     int a[5];
  526.     if (!getrectintarg(args, a))
  527.         return NULL;
  528.     wshade(a[0], a[1], a[2], a[3], a[4]);
  529.     INCREF(None);
  530.     return None;
  531. }
  532.  
  533. static object *
  534. drawing_text(dp, args)
  535.     drawingobject *dp;
  536.     object *args;
  537. {
  538.     int h, v, size;
  539.     char *text;
  540.     if (!getargs(args, "((ii)s#)", &h, &v, &text, &size))
  541.         return NULL;
  542.     wdrawtext(h, v, text, size);
  543.     INCREF(None);
  544.     return None;
  545. }
  546.  
  547. /* The following four are also used as stdwin functions */
  548.  
  549. static object *
  550. drawing_lineheight(dp, args)
  551.     drawingobject *dp;
  552.     object *args;
  553. {
  554.     if (!getnoarg(args))
  555.         return NULL;
  556.     return newintobject((long)wlineheight());
  557. }
  558.  
  559. static object *
  560. drawing_baseline(dp, args)
  561.     drawingobject *dp;
  562.     object *args;
  563. {
  564.     if (!getnoarg(args))
  565.         return NULL;
  566.     return newintobject((long)wbaseline());
  567. }
  568.  
  569. static object *
  570. drawing_textwidth(dp, args)
  571.     drawingobject *dp;
  572.     object *args;
  573. {
  574.     char *text;
  575.     int size;
  576.     if (!getargs(args, "s#", &text, &size))
  577.         return NULL;
  578.     return newintobject((long)wtextwidth(text, size));
  579. }
  580.  
  581. static object *
  582. drawing_textbreak(dp, args)
  583.     drawingobject *dp;
  584.     object *args;
  585. {
  586.     char *text;
  587.     int size, width;
  588.     if (!getargs(args, "(s#i)", &text, &size, &width))
  589.         return NULL;
  590.     return newintobject((long)wtextbreak(text, size, width));
  591. }
  592.  
  593. static object *
  594. drawing_setfont(self, args)
  595.     drawingobject *self;
  596.     object *args;
  597. {
  598.     char *font;
  599.     char style = '\0';
  600.     int size = 0;
  601.     if (args == NULL || !is_tupleobject(args)) {
  602.         if (!getargs(args, "z", &font))
  603.             return NULL;
  604.     }
  605.     else {
  606.         int n = gettuplesize(args);
  607.         if (n == 2) {
  608.             if (!getargs(args, "(zi)", &font, &size))
  609.                 return NULL;
  610.         }
  611.         else if (!getargs(args, "(zic)", &font, &size, &style)) {
  612.             err_clear();
  613.             if (!getargs(args, "(zci)", &font, &style, &size))
  614.                 return NULL;
  615.         }
  616.     }
  617.     if (font != NULL) {
  618.         if (!wsetfont(font)) {
  619.             err_setstr(StdwinError, "font not found");
  620.             return NULL;
  621.         }
  622.     }
  623.     if (size != 0)
  624.         wsetsize(size);
  625.     switch (style) {
  626.     case 'b':
  627.         wsetbold();
  628.         break;
  629.     case 'i':
  630.         wsetitalic();
  631.         break;
  632.     case 'o':
  633.         wsetbolditalic();
  634.         break;
  635.     case 'u':
  636.         wsetunderline();
  637.         break;
  638.     case 'p':
  639.         wsetplain();
  640.         break;
  641.     }
  642.     INCREF(None);
  643.     return None;
  644. }
  645.  
  646. static object *
  647. drawing_getbgcolor(self, args)
  648.     object *self;
  649.     object *args;
  650. {
  651.     if (!getnoarg(args))
  652.         return NULL;
  653.     return newintobject((long)wgetbgcolor());
  654. }
  655.  
  656. static object *
  657. drawing_getfgcolor(self, args)
  658.     object *self;
  659.     object *args;
  660. {
  661.     if (!getnoarg(args))
  662.         return NULL;
  663.     return newintobject((long)wgetfgcolor());
  664. }
  665.  
  666. static object *
  667. drawing_setbgcolor(self, args)
  668.     object *self;
  669.     object *args;
  670. {
  671.     long color;
  672.     if (!getlongarg(args, &color))
  673.         return NULL;
  674.     wsetbgcolor((COLOR)color);
  675.     INCREF(None);
  676.     return None;
  677. }
  678.  
  679. static object *
  680. drawing_setfgcolor(self, args)
  681.     object *self;
  682.     object *args;
  683. {
  684.     long color;
  685.     if (!getlongarg(args, &color))
  686.         return NULL;
  687.     wsetfgcolor((COLOR)color);
  688.     INCREF(None);
  689.     return None;
  690. }
  691.  
  692. #ifdef HAVE_BITMAPS
  693.  
  694. static object *
  695. drawing_bitmap(self, args)
  696.     object *self;
  697.     object *args;
  698. {
  699.     int h, v;
  700.     object *bp;
  701.     object *mask = NULL;
  702.     if (!getargs(args, "((ii)O)", &h, &v, &bp)) {
  703.         err_clear();
  704.         if (!getargs(args, "((ii)OO)", &h, &v, &bp, &mask))
  705.             return NULL;
  706.         if (mask == None)
  707.             mask = NULL;
  708.         else if (!is_bitmapobject(mask)) {
  709.             err_badarg();
  710.             return NULL;
  711.         }
  712.     }
  713.     if (!is_bitmapobject(bp)) {
  714.         err_badarg();
  715.         return NULL;
  716.     }
  717.     if (((bitmapobject *)bp)->b_bitmap == NULL ||
  718.         mask != NULL && ((bitmapobject *)mask)->b_bitmap == NULL) {
  719.         err_setstr(StdwinError, "bitmap object already close");
  720.         return NULL;
  721.     }
  722.     if (mask == NULL)
  723.         wdrawbitmap(h, v, ((bitmapobject *)bp)->b_bitmap, ALLBITS);
  724.     else
  725.         wdrawbitmap(h, v,
  726.                 ((bitmapobject *)bp)->b_bitmap,
  727.                 ((bitmapobject *)bp)->b_bitmap);
  728.     INCREF(None);
  729.     return None;
  730. }
  731.  
  732. #endif /* HAVE_BITMAPS */
  733.  
  734. static struct methodlist drawing_methods[] = {
  735. #ifdef HAVE_BITMAPS
  736.     {"bitmap",    (method)drawing_bitmap},
  737. #endif
  738.     {"box",        (method)drawing_box},
  739.     {"circle",    (method)drawing_circle},
  740.     {"cliprect",    (method)drawing_cliprect},
  741.     {"close",    (method)drawing_close},
  742.     {"elarc",    (method)drawing_elarc},
  743.     {"enddrawing",    (method)drawing_close},
  744.     {"erase",    (method)drawing_erase},
  745.     {"fillcircle",    (method)drawing_fillcircle},
  746.     {"fillelarc",    (method)drawing_fillelarc},
  747.     {"fillpoly",    (method)drawing_fillpoly},
  748.     {"invert",    (method)drawing_invert},
  749.     {"line",    (method)drawing_line},
  750.     {"noclip",    (method)drawing_noclip},
  751.     {"paint",    (method)drawing_paint},
  752.     {"poly",    (method)drawing_poly},
  753.     {"shade",    (method)drawing_shade},
  754.     {"text",    (method)drawing_text},
  755.     {"xorcircle",    (method)drawing_xorcircle},
  756.     {"xorelarc",    (method)drawing_xorelarc},
  757.     {"xorline",    (method)drawing_xorline},
  758.     {"xorpoly",    (method)drawing_xorpoly},
  759.     
  760.     /* Text measuring methods: */
  761.     {"baseline",    (method)drawing_baseline},
  762.     {"lineheight",    (method)drawing_lineheight},
  763.     {"textbreak",    (method)drawing_textbreak},
  764.     {"textwidth",    (method)drawing_textwidth},
  765.  
  766.     /* Font setting methods: */
  767.     {"setfont",    (method)drawing_setfont},
  768.     
  769.     /* Color methods: */
  770.     {"getbgcolor",    (method)drawing_getbgcolor},
  771.     {"getfgcolor",    (method)drawing_getfgcolor},
  772.     {"setbgcolor",    (method)drawing_setbgcolor},
  773.     {"setfgcolor",    (method)drawing_setfgcolor},
  774.  
  775.     {NULL,        NULL}        /* sentinel */
  776. };
  777.  
  778. static object *
  779. drawing_getattr(dp, name)
  780.     drawingobject *dp;
  781.     char *name;
  782. {
  783.     if (dp->d_ref == NULL) {
  784.         err_setstr(StdwinError, "drawing object already closed");
  785.         return NULL;
  786.     }
  787.     return findmethod(drawing_methods, (object *)dp, name);
  788. }
  789.  
  790. typeobject Drawingtype = {
  791.     OB_HEAD_INIT(&Typetype)
  792.     0,            /*ob_size*/
  793.     "drawing",        /*tp_name*/
  794.     sizeof(drawingobject),    /*tp_size*/
  795.     0,            /*tp_itemsize*/
  796.     /* methods */
  797.     (destructor)drawing_dealloc, /*tp_dealloc*/
  798.     0,            /*tp_print*/
  799.     (getattrfunc)drawing_getattr, /*tp_getattr*/
  800.     0,            /*tp_setattr*/
  801.     0,            /*tp_compare*/
  802.     0,            /*tp_repr*/
  803. };
  804.  
  805.  
  806. /* Text(edit) objects */
  807.  
  808. typedef struct {
  809.     OB_HEAD
  810.     TEXTEDIT    *t_text;
  811.     windowobject    *t_ref;
  812.     object        *t_attr;    /* Attributes dictionary */
  813. } textobject;
  814.  
  815. staticforward typeobject Texttype;
  816.  
  817. static textobject *
  818. newtextobject(wp, left, top, right, bottom)
  819.     windowobject *wp;
  820.     int left, top, right, bottom;
  821. {
  822.     textobject *tp;
  823.     tp = NEWOBJ(textobject, &Texttype);
  824.     if (tp == NULL)
  825.         return NULL;
  826.     tp->t_attr = NULL;
  827.     INCREF(wp);
  828.     tp->t_ref = wp;
  829.     tp->t_text = tecreate(wp->w_win, left, top, right, bottom);
  830.     if (tp->t_text == NULL) {
  831.         DECREF(tp);
  832.         return (textobject *) err_nomem();
  833.     }
  834.     return tp;
  835. }
  836.  
  837. /* Text(edit) methods */
  838.  
  839. static void
  840. text_dealloc(tp)
  841.     textobject *tp;
  842. {
  843.     if (tp->t_text != NULL)
  844.         tefree(tp->t_text);
  845.     XDECREF(tp->t_attr);
  846.     XDECREF(tp->t_ref);
  847.     DEL(tp);
  848. }
  849.  
  850. static object *
  851. text_close(tp, args)
  852.     textobject *tp;
  853.     object *args;
  854. {
  855.     if (tp->t_text != NULL) {
  856.         tefree(tp->t_text);
  857.         tp->t_text = NULL;
  858.     }
  859.     if (tp->t_attr != NULL) {
  860.         DECREF(tp->t_attr);
  861.         tp->t_attr = NULL;
  862.     }
  863.     if (tp->t_ref != NULL) {
  864.         DECREF(tp->t_ref);
  865.         tp->t_ref = NULL;
  866.     }
  867.     INCREF(None);
  868.     return None;
  869. }
  870.  
  871. static object *
  872. text_arrow(self, args)
  873.     textobject *self;
  874.     object *args;
  875. {
  876.     int code;
  877.     if (!getintarg(args, &code))
  878.         return NULL;
  879.     tearrow(self->t_text, code);
  880.     INCREF(None);
  881.     return None;
  882. }
  883.  
  884. static object *
  885. text_draw(self, args)
  886.     textobject *self;
  887.     object *args;
  888. {
  889.     register TEXTEDIT *tp = self->t_text;
  890.     int a[4];
  891.     int left, top, right, bottom;
  892.     if (!getrectarg(args, a))
  893.         return NULL;
  894.     if (Drawing != NULL) {
  895.         err_setstr(StdwinError, "already drawing");
  896.         return NULL;
  897.     }
  898.     /* Clip to text area and ignore if area is empty */
  899.     left = tegetleft(tp);
  900.     top = tegettop(tp);
  901.     right = tegetright(tp);
  902.     bottom = tegetbottom(tp);
  903.     if (a[0] < left) a[0] = left;
  904.     if (a[1] < top) a[1] = top;
  905.     if (a[2] > right) a[2] = right;
  906.     if (a[3] > bottom) a[3] = bottom;
  907.     if (a[0] < a[2] && a[1] < a[3]) {
  908.         wbegindrawing(self->t_ref->w_win);
  909.         tedrawnew(tp, a[0], a[1], a[2], a[3]);
  910.         wenddrawing(self->t_ref->w_win);
  911.     }
  912.     INCREF(None);
  913.     return None;
  914. }
  915.  
  916. static object *
  917. text_event(self, args)
  918.     textobject *self;
  919.     object *args;
  920. {
  921.     register TEXTEDIT *tp = self->t_text;
  922.     EVENT e;
  923.     if (!geteventarg(args, &e))
  924.         return NULL;
  925.     if (e.type == WE_MOUSE_DOWN) {
  926.         /* Cheat at the margins */
  927.         int width, height;
  928.         wgetdocsize(e.window, &width, &height);
  929.         if (e.u.where.h < 0 && tegetleft(tp) == 0)
  930.             e.u.where.h = 0;
  931.         else if (e.u.where.h > width && tegetright(tp) == width)
  932.             e.u.where.h = width;
  933.         if (e.u.where.v < 0 && tegettop(tp) == 0)
  934.             e.u.where.v = 0;
  935.         else if (e.u.where.v > height && tegetright(tp) == height)
  936.             e.u.where.v = height;
  937.     }
  938.     return newintobject((long) teevent(tp, &e));
  939. }
  940.  
  941. static object *
  942. text_getfocus(self, args)
  943.     textobject *self;
  944.     object *args;
  945. {
  946.     if (!getnoarg(args))
  947.         return NULL;
  948.     return makepoint(tegetfoc1(self->t_text), tegetfoc2(self->t_text));
  949. }
  950.  
  951. static object *
  952. text_getfocustext(self, args)
  953.     textobject *self;
  954.     object *args;
  955. {
  956.     int f1, f2;
  957.     char *text;
  958.     if (!getnoarg(args))
  959.         return NULL;
  960.     f1 = tegetfoc1(self->t_text);
  961.     f2 = tegetfoc2(self->t_text);
  962.     text = tegettext(self->t_text);
  963.     return newsizedstringobject(text + f1, f2-f1);
  964. }
  965.  
  966. static object *
  967. text_getrect(self, args)
  968.     textobject *self;
  969.     object *args;
  970. {
  971.     if (!getnoarg(args))
  972.         return NULL;
  973.     return makerect(tegetleft(self->t_text),
  974.             tegettop(self->t_text),
  975.             tegetright(self->t_text),
  976.             tegetbottom(self->t_text));
  977. }
  978.  
  979. static object *
  980. text_gettext(self, args)
  981.     textobject *self;
  982.     object *args;
  983. {
  984.     if (!getnoarg(args))
  985.         return NULL;
  986.     return newsizedstringobject(tegettext(self->t_text),
  987.                     tegetlen(self->t_text));
  988. }
  989.  
  990. static object *
  991. text_move(self, args)
  992.     textobject *self;
  993.     object *args;
  994. {
  995.     int a[4];
  996.     if (!getrectarg(args, a))
  997.         return NULL;
  998.     temovenew(self->t_text, a[0], a[1], a[2], a[3]);
  999.     INCREF(None);
  1000.     return None;
  1001. }
  1002.  
  1003. static object *
  1004. text_replace(self, args)
  1005.     textobject *self;
  1006.     object *args;
  1007. {
  1008.     char *text;
  1009.     if (!getstrarg(args, &text))
  1010.         return NULL;
  1011.     tereplace(self->t_text, text);
  1012.     INCREF(None);
  1013.     return None;
  1014. }
  1015.  
  1016. static object *
  1017. text_setactive(self, args)
  1018.     textobject *self;
  1019.     object *args;
  1020. {
  1021.     int flag;
  1022.     if (!getintarg(args, &flag))
  1023.         return NULL;
  1024.     tesetactive(self->t_text, flag);
  1025.     INCREF(None);
  1026.     return None;
  1027. }
  1028.  
  1029. static object *
  1030. text_setfocus(self, args)
  1031.     textobject *self;
  1032.     object *args;
  1033. {
  1034.     int a[2];
  1035.     if (!getpointarg(args, a))
  1036.         return NULL;
  1037.     tesetfocus(self->t_text, a[0], a[1]);
  1038.     INCREF(None);
  1039.     return None;
  1040. }
  1041.  
  1042. static object *
  1043. text_settext(self, args)
  1044.     textobject *self;
  1045.     object *args;
  1046. {
  1047.     char *text;
  1048.     char *buf;
  1049.     int size;
  1050.     if (!getargs(args, "s#", &text, &size))
  1051.         return NULL;
  1052.     if ((buf = NEW(char, size)) == NULL) {
  1053.         return err_nomem();
  1054.     }
  1055.     memcpy(buf, text, size);
  1056.     tesetbuf(self->t_text, buf, size); /* Becomes owner of buffer */
  1057.     INCREF(None);
  1058.     return None;
  1059. }
  1060.  
  1061. static object *
  1062. text_setview(self, args)
  1063.     textobject *self;
  1064.     object *args;
  1065. {
  1066.     int a[4];
  1067.     if (args == None)
  1068.         tenoview(self->t_text);
  1069.     else {
  1070.         if (!getrectarg(args, a))
  1071.             return NULL;
  1072.         tesetview(self->t_text, a[0], a[1], a[2], a[3]);
  1073.     }
  1074.     INCREF(None);
  1075.     return None;
  1076. }
  1077.  
  1078. static struct methodlist text_methods[] = {
  1079.     {"arrow",    (method)text_arrow},
  1080.     {"close",    (method)text_close},
  1081.     {"draw",    (method)text_draw},
  1082.     {"event",    (method)text_event},
  1083.     {"getfocus",    (method)text_getfocus},
  1084.     {"getfocustext",(method)text_getfocustext},
  1085.     {"getrect",    (method)text_getrect},
  1086.     {"gettext",    (method)text_gettext},
  1087.     {"move",    (method)text_move},
  1088.     {"replace",    (method)text_replace},
  1089.     {"setactive",    (method)text_setactive},
  1090.     {"setfocus",    (method)text_setfocus},
  1091.     {"settext",    (method)text_settext},
  1092.     {"setview",    (method)text_setview},
  1093.     {NULL,        NULL}        /* sentinel */
  1094. };
  1095.  
  1096. static object *
  1097. text_getattr(tp, name)
  1098.     textobject *tp;
  1099.     char *name;
  1100. {
  1101.     object *v = NULL;
  1102.     if (tp->t_ref == NULL) {
  1103.         err_setstr(StdwinError, "text object already closed");
  1104.         return NULL;
  1105.     }
  1106.     if (strcmp(name, "__dict__") == 0) {
  1107.         v = tp->t_attr;
  1108.         if (v == NULL)
  1109.             v = None;
  1110.     }
  1111.     else if (tp->t_attr != NULL) {
  1112.         v = dictlookup(tp->t_attr, name);
  1113.     }
  1114.     if (v != NULL) {
  1115.         INCREF(v);
  1116.         return v;
  1117.     }
  1118.     return findmethod(text_methods, (object *)tp, name);
  1119. }
  1120.  
  1121. static int
  1122. text_setattr(tp, name, v)
  1123.     textobject *tp;
  1124.     char *name;
  1125.     object *v;
  1126. {
  1127.     if (tp->t_attr == NULL) {
  1128.         tp->t_attr = newdictobject();
  1129.         if (tp->t_attr == NULL)
  1130.             return -1;
  1131.     }
  1132.     if (v == NULL) {
  1133.         int rv = dictremove(tp->t_attr, name);
  1134.         if (rv < 0)
  1135.             err_setstr(AttributeError,
  1136.                     "delete non-existing text object attribute");
  1137.         return rv;
  1138.     }
  1139.     else
  1140.         return dictinsert(tp->t_attr, name, v);
  1141. }
  1142.  
  1143. statichere typeobject Texttype = {
  1144.     OB_HEAD_INIT(&Typetype)
  1145.     0,            /*ob_size*/
  1146.     "textedit",        /*tp_name*/
  1147.     sizeof(textobject),    /*tp_size*/
  1148.     0,            /*tp_itemsize*/
  1149.     /* methods */
  1150.     (destructor)text_dealloc, /*tp_dealloc*/
  1151.     0,            /*tp_print*/
  1152.     (getattrfunc)text_getattr, /*tp_getattr*/
  1153.     (setattrfunc)text_setattr, /*tp_setattr*/
  1154.     0,            /*tp_compare*/
  1155.     0,            /*tp_repr*/
  1156. };
  1157.  
  1158.  
  1159. /* Menu objects */
  1160.  
  1161. #define IDOFFSET 10        /* Menu IDs we use start here */
  1162. #define MAXNMENU 200        /* Max #menus we allow */
  1163. static menuobject *menulist[MAXNMENU];
  1164.  
  1165. static menuobject *newmenuobject PROTO((char *));
  1166. static menuobject *
  1167. newmenuobject(title)
  1168.     char *title;
  1169. {
  1170.     int id;
  1171.     MENU *menu;
  1172.     menuobject *mp;
  1173.     for (id = 0; id < MAXNMENU; id++) {
  1174.         if (menulist[id] == NULL)
  1175.             break;
  1176.     }
  1177.     if (id >= MAXNMENU) {
  1178.         err_setstr(StdwinError, "creating too many menus");
  1179.         return NULL;
  1180.     }
  1181.     menu = wmenucreate(id + IDOFFSET, title);
  1182.     if (menu == NULL)
  1183.         return (menuobject *) err_nomem();
  1184.     mp = NEWOBJ(menuobject, &Menutype);
  1185.     if (mp != NULL) {
  1186.         mp->m_menu = menu;
  1187.         mp->m_id = id + IDOFFSET;
  1188.         mp->m_attr = NULL;
  1189.         menulist[id] = mp;
  1190.     }
  1191.     else
  1192.         wmenudelete(menu);
  1193.     return mp;
  1194. }
  1195.  
  1196. /* Menu methods */
  1197.  
  1198. static void
  1199. menu_dealloc(mp)
  1200.     menuobject *mp;
  1201. {
  1202.     
  1203.     int id = mp->m_id - IDOFFSET;
  1204.     if (id >= 0 && id < MAXNMENU && menulist[id] == mp) {
  1205.         menulist[id] = NULL;
  1206.     }
  1207.     if (mp->m_menu != NULL)
  1208.         wmenudelete(mp->m_menu);
  1209.     XDECREF(mp->m_attr);
  1210.     DEL(mp);
  1211. }
  1212.  
  1213. static object *
  1214. menu_close(mp, args)
  1215.     menuobject *mp;
  1216.     object *args;
  1217. {
  1218.     int id = mp->m_id - IDOFFSET;
  1219.     if (id >= 0 && id < MAXNMENU && menulist[id] == mp) {
  1220.         menulist[id] = NULL;
  1221.     }
  1222.     mp->m_id = -1;
  1223.     if (mp->m_menu != NULL)
  1224.         wmenudelete(mp->m_menu);
  1225.     mp->m_menu = NULL;
  1226.     XDECREF(mp->m_attr);
  1227.     mp->m_attr = NULL;
  1228.     INCREF(None);
  1229.     return None;
  1230. }
  1231.  
  1232. static object *
  1233. menu_additem(self, args)
  1234.     menuobject *self;
  1235.     object *args;
  1236. {
  1237.     char *text;
  1238.     int shortcut = -1;
  1239.     if (is_tupleobject(args)) {
  1240.         char c;
  1241.         if (!getargs(args, "(sc)", &text, &c))
  1242.             return NULL;
  1243.         shortcut = c;
  1244.     }
  1245.     else if (!getstrarg(args, &text))
  1246.         return NULL;
  1247.     wmenuadditem(self->m_menu, text, shortcut);
  1248.     INCREF(None);
  1249.     return None;
  1250. }
  1251.  
  1252. static object *
  1253. menu_setitem(self, args)
  1254.     menuobject *self;
  1255.     object *args;
  1256. {
  1257.     int index;
  1258.     char *text;
  1259.     if (!getargs(args, "(is)", &index, &text))
  1260.         return NULL;
  1261.     wmenusetitem(self->m_menu, index, text);
  1262.     INCREF(None);
  1263.     return None;
  1264. }
  1265.  
  1266. static object *
  1267. menu_enable(self, args)
  1268.     menuobject *self;
  1269.     object *args;
  1270. {
  1271.     int index;
  1272.     int flag;
  1273.     if (!getargs(args, "(ii)", &index, &flag))
  1274.         return NULL;
  1275.     wmenuenable(self->m_menu, index, flag);
  1276.     INCREF(None);
  1277.     return None;
  1278. }
  1279.  
  1280. static object *
  1281. menu_check(self, args)
  1282.     menuobject *self;
  1283.     object *args;
  1284. {
  1285.     int index;
  1286.     int flag;
  1287.     if (!getargs(args, "(ii)", &index, &flag))
  1288.         return NULL;
  1289.     wmenucheck(self->m_menu, index, flag);
  1290.     INCREF(None);
  1291.     return None;
  1292. }
  1293.  
  1294. static struct methodlist menu_methods[] = {
  1295.     {"additem",    (method)menu_additem},
  1296.     {"setitem",    (method)menu_setitem},
  1297.     {"enable",    (method)menu_enable},
  1298.     {"check",    (method)menu_check},
  1299.     {"close",    (method)menu_close},
  1300.     {NULL,        NULL}        /* sentinel */
  1301. };
  1302.  
  1303. static object *
  1304. menu_getattr(mp, name)
  1305.     menuobject *mp;
  1306.     char *name;
  1307. {
  1308.     object *v = NULL;
  1309.     if (mp->m_menu == NULL) {
  1310.         err_setstr(StdwinError, "menu object already closed");
  1311.         return NULL;
  1312.     }
  1313.     if (strcmp(name, "__dict__") == 0) {
  1314.         v = mp->m_attr;
  1315.         if (v == NULL)
  1316.             v = None;
  1317.     }
  1318.     else if (mp->m_attr != NULL) {
  1319.         v = dictlookup(mp->m_attr, name);
  1320.     }
  1321.     if (v != NULL) {
  1322.         INCREF(v);
  1323.         return v;
  1324.     }
  1325.     return findmethod(menu_methods, (object *)mp, name);
  1326. }
  1327.  
  1328. static int
  1329. menu_setattr(mp, name, v)
  1330.     menuobject *mp;
  1331.     char *name;
  1332.     object *v;
  1333. {
  1334.     if (mp->m_attr == NULL) {
  1335.         mp->m_attr = newdictobject();
  1336.         if (mp->m_attr == NULL)
  1337.             return -1;
  1338.     }
  1339.     if (v == NULL) {
  1340.         int rv = dictremove(mp->m_attr, name);
  1341.         if (rv < 0)
  1342.             err_setstr(AttributeError,
  1343.                     "delete non-existing menu object attribute");
  1344.         return rv;
  1345.     }
  1346.     else
  1347.         return dictinsert(mp->m_attr, name, v);
  1348. }
  1349.  
  1350. statichere typeobject Menutype = {
  1351.     OB_HEAD_INIT(&Typetype)
  1352.     0,            /*ob_size*/
  1353.     "menu",            /*tp_name*/
  1354.     sizeof(menuobject),    /*tp_size*/
  1355.     0,            /*tp_itemsize*/
  1356.     /* methods */
  1357.     (destructor)menu_dealloc, /*tp_dealloc*/
  1358.     0,            /*tp_print*/
  1359.     (getattrfunc)menu_getattr, /*tp_getattr*/
  1360.     (setattrfunc)menu_setattr, /*tp_setattr*/
  1361.     0,            /*tp_compare*/
  1362.     0,            /*tp_repr*/
  1363. };
  1364.  
  1365.  
  1366. #ifdef HAVE_BITMAPS
  1367.  
  1368. /* Bitmaps objects */
  1369.  
  1370. static bitmapobject *newbitmapobject PROTO((int, int));
  1371. static bitmapobject *
  1372. newbitmapobject(width, height)
  1373.     int width, height;
  1374. {
  1375.     BITMAP *bitmap;
  1376.     bitmapobject *bp;
  1377.     bitmap = wnewbitmap(width, height);
  1378.     if (bitmap == NULL)
  1379.         return (bitmapobject *) err_nomem();
  1380.     bp = NEWOBJ(bitmapobject, &Bitmaptype);
  1381.     if (bp != NULL) {
  1382.         bp->b_bitmap = bitmap;
  1383.         bp->b_attr = NULL;
  1384.     }
  1385.     else
  1386.         wfreebitmap(bitmap);
  1387.     return bp;
  1388. }
  1389.  
  1390. /* Bitmap methods */
  1391.  
  1392. static void
  1393. bitmap_dealloc(bp)
  1394.     bitmapobject *bp;
  1395. {
  1396.     if (bp->b_bitmap != NULL)
  1397.         wfreebitmap(bp->b_bitmap);
  1398.     XDECREF(bp->b_attr);
  1399.     DEL(bp);
  1400. }
  1401.  
  1402. static object *
  1403. bitmap_close(bp, args)
  1404.     bitmapobject *bp;
  1405.     object *args;
  1406. {
  1407.     if (bp->b_bitmap != NULL)
  1408.         wfreebitmap(bp->b_bitmap);
  1409.     bp->b_bitmap = NULL;
  1410.     XDECREF(bp->b_attr);
  1411.     bp->b_attr = NULL;
  1412.     INCREF(None);
  1413.     return None;
  1414. }
  1415.  
  1416. static object *
  1417. bitmap_setbit(self, args)
  1418.     bitmapobject *self;
  1419.     object *args;
  1420. {
  1421.     int a[3];
  1422.     if (!getpointintarg(args, a))
  1423.         return NULL;
  1424.     wsetbit(self->b_bitmap, a[0], a[1], a[2]);
  1425.     INCREF(None);
  1426.     return None;
  1427. }
  1428.  
  1429. static object *
  1430. bitmap_getbit(self, args)
  1431.     bitmapobject *self;
  1432.     object *args;
  1433. {
  1434.     int a[2];
  1435.     if (!getpointarg(args, a))
  1436.         return NULL;
  1437.     return newintobject((long) wgetbit(self->b_bitmap, a[0], a[1]));
  1438. }
  1439.  
  1440. static object *
  1441. bitmap_getsize(self, args)
  1442.     bitmapobject *self;
  1443.     object *args;
  1444. {
  1445.     int width, height;
  1446.     if (!getnoarg(args))
  1447.         return NULL;
  1448.     wgetbitmapsize(self->b_bitmap, &width, &height);
  1449.     return mkvalue("(ii)", width, height);
  1450. }
  1451.  
  1452. static struct methodlist bitmap_methods[] = {
  1453.     {"close",    (method)bitmap_close},
  1454.     {"getsize",    (method)bitmap_getsize},
  1455.     {"getbit",    (method)bitmap_getbit},
  1456.     {"setbit",    (method)bitmap_setbit},
  1457.     {NULL,        NULL}        /* sentinel */
  1458. };
  1459.  
  1460. static object *
  1461. bitmap_getattr(bp, name)
  1462.     bitmapobject *bp;
  1463.     char *name;
  1464. {
  1465.     object *v = NULL;
  1466.     if (bp->b_bitmap == NULL) {
  1467.         err_setstr(StdwinError, "bitmap object already closed");
  1468.         return NULL;
  1469.     }
  1470.     if (strcmp(name, "__dict__") == 0) {
  1471.         v = bp->b_attr;
  1472.         if (v == NULL)
  1473.             v = None;
  1474.     }
  1475.     else if (bp->b_attr != NULL) {
  1476.         v = dictlookup(bp->b_attr, name);
  1477.     }
  1478.     if (v != NULL) {
  1479.         INCREF(v);
  1480.         return v;
  1481.     }
  1482.     return findmethod(bitmap_methods, (object *)bp, name);
  1483. }
  1484.  
  1485. static int
  1486. bitmap_setattr(bp, name, v)
  1487.     bitmapobject *bp;
  1488.     char *name;
  1489.     object *v;
  1490. {
  1491.     if (bp->b_attr == NULL) {
  1492.         bp->b_attr = newdictobject();
  1493.         if (bp->b_attr == NULL)
  1494.             return -1;
  1495.     }
  1496.     if (v == NULL) {
  1497.         int rv = dictremove(bp->b_attr, name);
  1498.         if (rv < 0)
  1499.             err_setstr(AttributeError,
  1500.                     "delete non-existing bitmap object attribute");
  1501.         return rv;
  1502.     }
  1503.     else
  1504.         return dictinsert(bp->b_attr, name, v);
  1505. }
  1506.  
  1507. statichere typeobject Bitmaptype = {
  1508.     OB_HEAD_INIT(&Typetype)
  1509.     0,            /*ob_size*/
  1510.     "bitmap",            /*tp_name*/
  1511.     sizeof(bitmapobject),    /*tp_size*/
  1512.     0,            /*tp_itemsize*/
  1513.     /* methods */
  1514.     (destructor)bitmap_dealloc, /*tp_dealloc*/
  1515.     0,            /*tp_print*/
  1516.     (getattrfunc)bitmap_getattr, /*tp_getattr*/
  1517.     (setattrfunc)bitmap_setattr, /*tp_setattr*/
  1518.     0,            /*tp_compare*/
  1519.     0,            /*tp_repr*/
  1520. };
  1521.  
  1522. #endif /* HAVE_BITMAPS */
  1523.  
  1524.  
  1525. /* Windows */
  1526.  
  1527. #define MAXNWIN 50
  1528. static windowobject *windowlist[MAXNWIN];
  1529.  
  1530. /* Window methods */
  1531.  
  1532. static void
  1533. window_dealloc(wp)
  1534.     windowobject *wp;
  1535. {
  1536.     if (wp->w_win != NULL) {
  1537.         int tag = wgettag(wp->w_win);
  1538.         if (tag >= 0 && tag < MAXNWIN)
  1539.             windowlist[tag] = NULL;
  1540.         else
  1541.             fprintf(stderr, "XXX help! tag %d in window_dealloc\n",
  1542.                 tag);
  1543.         wclose(wp->w_win);
  1544.     }
  1545.     DECREF(wp->w_title);
  1546.     if (wp->w_attr != NULL)
  1547.         DECREF(wp->w_attr);
  1548.     free((char *)wp);
  1549. }
  1550.  
  1551. static object *
  1552. window_close(wp, args)
  1553.     windowobject *wp;
  1554.     object *args;
  1555. {
  1556.     if (wp->w_win != NULL) {
  1557.         int tag = wgettag(wp->w_win);
  1558.         if (tag >= 0 && tag < MAXNWIN)
  1559.             windowlist[tag] = NULL;
  1560.         wclose(wp->w_win);
  1561.         wp->w_win = NULL;
  1562.     }
  1563.     INCREF(None);
  1564.     return None;
  1565. }
  1566.  
  1567. static object *
  1568. window_begindrawing(wp, args)
  1569.     windowobject *wp;
  1570.     object *args;
  1571. {
  1572.     drawingobject *dp;
  1573.     if (!getnoarg(args))
  1574.         return NULL;
  1575.     if (Drawing != NULL) {
  1576.         err_setstr(StdwinError, "already drawing");
  1577.         return NULL;
  1578.     }
  1579.     dp = NEWOBJ(drawingobject, &Drawingtype);
  1580.     if (dp == NULL)
  1581.         return NULL;
  1582.     Drawing = dp;
  1583.     INCREF(wp);
  1584.     dp->d_ref = wp;
  1585.     wbegindrawing(wp->w_win);
  1586.     return (object *)dp;
  1587. }
  1588.  
  1589. static object *
  1590. window_change(wp, args)
  1591.     windowobject *wp;
  1592.     object *args;
  1593. {
  1594.     int a[4];
  1595.     if (!getrectarg(args, a))
  1596.         return NULL;
  1597.     wchange(wp->w_win, a[0], a[1], a[2], a[3]);
  1598.     INCREF(None);
  1599.     return None;
  1600. }
  1601.  
  1602. static object *
  1603. window_gettitle(wp, args)
  1604.     windowobject *wp;
  1605.     object *args;
  1606. {
  1607.     if (!getnoarg(args))
  1608.         return NULL;
  1609.     INCREF(wp->w_title);
  1610.     return wp->w_title;
  1611. }
  1612.  
  1613. static object *
  1614. window_getwinpos(wp, args)
  1615.     windowobject *wp;
  1616.     object *args;
  1617. {
  1618.     int h, v;
  1619.     if (!getnoarg(args))
  1620.         return NULL;
  1621.     wgetwinpos(wp->w_win, &h, &v);
  1622.     return makepoint(h, v);
  1623. }
  1624.  
  1625. static object *
  1626. window_getwinsize(wp, args)
  1627.     windowobject *wp;
  1628.     object *args;
  1629. {
  1630.     int width, height;
  1631.     if (!getnoarg(args))
  1632.         return NULL;
  1633.     wgetwinsize(wp->w_win, &width, &height);
  1634.     return makepoint(width, height);
  1635. }
  1636.  
  1637. static object *
  1638. window_setwinpos(wp, args)
  1639.     windowobject *wp;
  1640.     object *args;
  1641. {
  1642.     int a[2];
  1643.     if (!getpointarg(args, a))
  1644.         return NULL;
  1645.     wsetwinpos(wp->w_win, a[0], a[1]);
  1646.     INCREF(None);
  1647.     return None;
  1648. }
  1649.  
  1650. static object *
  1651. window_setwinsize(wp, args)
  1652.     windowobject *wp;
  1653.     object *args;
  1654. {
  1655.     int a[2];
  1656.     if (!getpointarg(args, a))
  1657.         return NULL;
  1658.     wsetwinsize(wp->w_win, a[0], a[1]);
  1659.     INCREF(None);
  1660.     return None;
  1661. }
  1662.  
  1663. static object *
  1664. window_getdocsize(wp, args)
  1665.     windowobject *wp;
  1666.     object *args;
  1667. {
  1668.     int width, height;
  1669.     if (!getnoarg(args))
  1670.         return NULL;
  1671.     wgetdocsize(wp->w_win, &width, &height);
  1672.     return makepoint(width, height);
  1673. }
  1674.  
  1675. static object *
  1676. window_getorigin(wp, args)
  1677.     windowobject *wp;
  1678.     object *args;
  1679. {
  1680.     int width, height;
  1681.     if (!getnoarg(args))
  1682.         return NULL;
  1683.     wgetorigin(wp->w_win, &width, &height);
  1684.     return makepoint(width, height);
  1685. }
  1686.  
  1687. static object *
  1688. window_scroll(wp, args)
  1689.     windowobject *wp;
  1690.     object *args;
  1691. {
  1692.     int a[6];
  1693.     if (!getrectpointarg(args, a))
  1694.         return NULL;
  1695.     wscroll(wp->w_win, a[0], a[1], a[2], a[3], a[4], a[5]);
  1696.     INCREF(None);
  1697.     return None;
  1698. }
  1699.  
  1700. static object *
  1701. window_setdocsize(wp, args)
  1702.     windowobject *wp;
  1703.     object *args;
  1704. {
  1705.     int a[2];
  1706.     if (!getpointarg(args, a))
  1707.         return NULL;
  1708.     wsetdocsize(wp->w_win, a[0], a[1]);
  1709.     INCREF(None);
  1710.     return None;
  1711. }
  1712.  
  1713. static object *
  1714. window_setorigin(wp, args)
  1715.     windowobject *wp;
  1716.     object *args;
  1717. {
  1718.     int a[2];
  1719.     if (!getpointarg(args, a))
  1720.         return NULL;
  1721.     wsetorigin(wp->w_win, a[0], a[1]);
  1722.     INCREF(None);
  1723.     return None;
  1724. }
  1725.  
  1726. static object *
  1727. window_settitle(wp, args)
  1728.     windowobject *wp;
  1729.     object *args;
  1730. {
  1731.     object *title;
  1732.     if (!getargs(args, "S", &title))
  1733.         return NULL;
  1734.     DECREF(wp->w_title);
  1735.     INCREF(title);
  1736.     wp->w_title = title;
  1737.     wsettitle(wp->w_win, getstringvalue(title));
  1738.     INCREF(None);
  1739.     return None;
  1740. }
  1741.  
  1742. static object *
  1743. window_show(wp, args)
  1744.     windowobject *wp;
  1745.     object *args;
  1746. {
  1747.     int a[4];
  1748.     if (!getrectarg(args, a))
  1749.         return NULL;
  1750.     wshow(wp->w_win, a[0], a[1], a[2], a[3]);
  1751.     INCREF(None);
  1752.     return None;
  1753. }
  1754.  
  1755. static object *
  1756. window_settimer(wp, args)
  1757.     windowobject *wp;
  1758.     object *args;
  1759. {
  1760.     int a;
  1761.     if (!getintarg(args, &a))
  1762.         return NULL;
  1763.     wsettimer(wp->w_win, a);
  1764.     INCREF(None);
  1765.     return None;
  1766. }
  1767.  
  1768. static object *
  1769. window_menucreate(self, args)
  1770.     windowobject *self;
  1771.     object *args;
  1772. {
  1773.     menuobject *mp;
  1774.     char *title;
  1775.     if (!getstrarg(args, &title))
  1776.         return NULL;
  1777.     wmenusetdeflocal(1);
  1778.     mp = newmenuobject(title);
  1779.     if (mp == NULL)
  1780.         return NULL;
  1781.     wmenuattach(self->w_win, mp->m_menu);
  1782.     return (object *)mp;
  1783. }
  1784.  
  1785. static object *
  1786. window_textcreate(self, args)
  1787.     windowobject *self;
  1788.     object *args;
  1789. {
  1790.     int a[4];
  1791.     if (!getrectarg(args, a))
  1792.         return NULL;
  1793.     return (object *)
  1794.         newtextobject(self, a[0], a[1], a[2], a[3]);
  1795. }
  1796.  
  1797. static object *
  1798. window_setselection(self, args)
  1799.     windowobject *self;
  1800.     object *args;
  1801. {
  1802.     int sel, size, ok;
  1803.     char *text;
  1804.     if (!getargs(args, "(is#)", &sel, &text, &size))
  1805.         return NULL;
  1806.     ok = wsetselection(self->w_win, sel, text, size);
  1807.     return newintobject(ok);
  1808. }
  1809.  
  1810. static object *
  1811. window_setwincursor(self, args)
  1812.     windowobject *self;
  1813.     object *args;
  1814. {
  1815.     char *name;
  1816.     CURSOR *c;
  1817.     if (!getargs(args, "z", &name))
  1818.         return NULL;
  1819.     if (name == NULL)
  1820.         c = NULL;
  1821.     else {
  1822.         c = wfetchcursor(name);
  1823.         if (c == NULL) {
  1824.             err_setstr(StdwinError, "no such cursor");
  1825.             return NULL;
  1826.         }
  1827.     }
  1828.     wsetwincursor(self->w_win, c);
  1829.     INCREF(None);
  1830.     return None;
  1831. }
  1832.  
  1833. static object *
  1834. window_setactive(self, args)
  1835.     windowobject *self;
  1836.     object *args;
  1837. {
  1838.     if (!getnoarg(args))
  1839.         return NULL;
  1840.     wsetactive(self->w_win);
  1841.     INCREF(None);
  1842.     return None;
  1843. }
  1844.  
  1845. #ifdef CWI_HACKS
  1846. static object *
  1847. window_getxwindowid(self, args)
  1848.     windowobject *self;
  1849.     object *args;
  1850. {
  1851.     long wid = wgetxwindowid(self->w_win);
  1852.     return newintobject(wid);
  1853. }
  1854. #endif
  1855.  
  1856. static struct methodlist window_methods[] = {
  1857.     {"begindrawing",(method)window_begindrawing},
  1858.     {"change",    (method)window_change},
  1859.     {"close",    (method)window_close},
  1860.     {"getdocsize",    (method)window_getdocsize},
  1861.     {"getorigin",    (method)window_getorigin},
  1862.     {"gettitle",    (method)window_gettitle},
  1863.     {"getwinpos",    (method)window_getwinpos},
  1864.     {"getwinsize",    (method)window_getwinsize},
  1865.     {"menucreate",    (method)window_menucreate},
  1866.     {"scroll",    (method)window_scroll},
  1867.     {"setactive",    (method)window_setactive},
  1868.     {"setdocsize",    (method)window_setdocsize},
  1869.     {"setorigin",    (method)window_setorigin},
  1870.     {"setselection",(method)window_setselection},
  1871.     {"settimer",    (method)window_settimer},
  1872.     {"settitle",    (method)window_settitle},
  1873.     {"setwincursor",(method)window_setwincursor},
  1874.     {"setwinpos",    (method)window_setwinpos},
  1875.     {"setwinsize",    (method)window_setwinsize},
  1876.     {"show",    (method)window_show},
  1877.     {"textcreate",    (method)window_textcreate},
  1878. #ifdef CWI_HACKS
  1879.     {"getxwindowid",(method)window_getxwindowid},
  1880. #endif
  1881.     {NULL,        NULL}        /* sentinel */
  1882. };
  1883.  
  1884. static object *
  1885. window_getattr(wp, name)
  1886.     windowobject *wp;
  1887.     char *name;
  1888. {
  1889.     object *v = NULL;
  1890.     if (wp->w_win == NULL) {
  1891.         err_setstr(StdwinError, "window already closed");
  1892.         return NULL;
  1893.     }
  1894.     if (strcmp(name, "__dict__") == 0) {
  1895.         v = wp->w_attr;
  1896.         if (v == NULL)
  1897.             v = None;
  1898.     }
  1899.     else if (wp->w_attr != NULL) {
  1900.         v = dictlookup(wp->w_attr, name);
  1901.     }
  1902.     if (v != NULL) {
  1903.         INCREF(v);
  1904.         return v;
  1905.     }
  1906.     return findmethod(window_methods, (object *)wp, name);
  1907. }
  1908.  
  1909. static int
  1910. window_setattr(wp, name, v)
  1911.     windowobject *wp;
  1912.     char *name;
  1913.     object *v;
  1914. {
  1915.     if (wp->w_attr == NULL) {
  1916.         wp->w_attr = newdictobject();
  1917.         if (wp->w_attr == NULL)
  1918.             return -1;
  1919.     }
  1920.     if (v == NULL) {
  1921.         int rv = dictremove(wp->w_attr, name);
  1922.         if (rv < 0)
  1923.             err_setstr(AttributeError,
  1924.                     "delete non-existing menu object attribute");
  1925.         return rv;
  1926.     }
  1927.     else
  1928.         return dictinsert(wp->w_attr, name, v);
  1929. }
  1930.  
  1931. statichere typeobject Windowtype = {
  1932.     OB_HEAD_INIT(&Typetype)
  1933.     0,            /*ob_size*/
  1934.     "window",        /*tp_name*/
  1935.     sizeof(windowobject),    /*tp_size*/
  1936.     0,            /*tp_itemsize*/
  1937.     /* methods */
  1938.     (destructor)window_dealloc, /*tp_dealloc*/
  1939.     0,            /*tp_print*/
  1940.     (getattrfunc)window_getattr, /*tp_getattr*/
  1941.     (setattrfunc)window_setattr, /*tp_setattr*/
  1942.     0,            /*tp_compare*/
  1943.     0,            /*tp_repr*/
  1944. };
  1945.  
  1946. /* Stdwin methods */
  1947.  
  1948. static object *
  1949. stdwin_done(sw, args)
  1950.     object *sw;
  1951.     object *args;
  1952. {
  1953.     if (!getnoarg(args))
  1954.         return NULL;
  1955.     wdone();
  1956.     /* XXX There is no protection against continued use of
  1957.        XXX stdwin functions or objects after this call is made.
  1958.        XXX Use at own risk */
  1959.     INCREF(None);
  1960.     return None;
  1961. }
  1962.  
  1963. static object *
  1964. stdwin_open(sw, args)
  1965.     object *sw;
  1966.     object *args;
  1967. {
  1968.     int tag;
  1969.     object *title;
  1970.     windowobject *wp;
  1971.     if (!getargs(args, "S", &title))
  1972.         return NULL;
  1973.     for (tag = 0; tag < MAXNWIN; tag++) {
  1974.         if (windowlist[tag] == NULL)
  1975.             break;
  1976.     }
  1977.     if (tag >= MAXNWIN) {
  1978.         err_setstr(StdwinError, "creating too many windows");
  1979.         return NULL;
  1980.     }
  1981.     wp = NEWOBJ(windowobject, &Windowtype);
  1982.     if (wp == NULL)
  1983.         return NULL;
  1984.     INCREF(title);
  1985.     wp->w_title = title;
  1986.     wp->w_win = wopen(getstringvalue(title), (void (*)()) NULL);
  1987.     wp->w_attr = NULL;
  1988.     if (wp->w_win == NULL) {
  1989.         DECREF(wp);
  1990.         return NULL;
  1991.     }
  1992.     windowlist[tag] = wp;
  1993.     wsettag(wp->w_win, tag);
  1994.     return (object *)wp;
  1995. }
  1996.  
  1997. static object *
  1998. window2object(win)
  1999.     WINDOW *win;
  2000. {
  2001.     object *w;
  2002.     if (win == NULL)
  2003.         w = None;
  2004.     else {
  2005.         int tag = wgettag(win);
  2006.         if (tag < 0 || tag >= MAXNWIN || windowlist[tag] == NULL ||
  2007.             windowlist[tag]->w_win != win)
  2008.             w = None;
  2009.         else
  2010.             w = (object *)windowlist[tag];
  2011.     }
  2012.     INCREF(w);
  2013.     return w;
  2014. }
  2015.  
  2016. static object *
  2017. stdwin_get_poll_event(poll, args)
  2018.     int poll;
  2019.     object *args;
  2020. {
  2021.     EVENT e;
  2022.     object *u, *v, *w;
  2023.     if (!getnoarg(args))
  2024.         return NULL;
  2025.     if (Drawing != NULL) {
  2026.         err_setstr(StdwinError, "cannot getevent() while drawing");
  2027.         return NULL;
  2028.     }
  2029.  again:
  2030.     BGN_STDWIN
  2031.     if (poll) {
  2032.         if (!wpollevent(&e)) {
  2033.             RET_STDWIN
  2034.             INCREF(None);
  2035.             return None;
  2036.         }
  2037.     }
  2038.     else
  2039.         wgetevent(&e);
  2040.     END_STDWIN
  2041.     if (e.type == WE_COMMAND && e.u.command == WC_CANCEL) {
  2042.         /* Turn keyboard interrupts into exceptions */
  2043.         err_set(KeyboardInterrupt);
  2044.         return NULL;
  2045.     }
  2046.     if (e.type == WE_COMMAND && e.u.command == WC_CLOSE) {
  2047.         /* Turn WC_CLOSE commands into WE_CLOSE events */
  2048.         e.type = WE_CLOSE;
  2049.     }
  2050.     v = window2object(e.window);
  2051.     switch (e.type) {
  2052.     case WE_CHAR:
  2053.         {
  2054.             char c[1];
  2055.             c[0] = e.u.character;
  2056.             w = newsizedstringobject(c, 1);
  2057.         }
  2058.         break;
  2059.     case WE_COMMAND:
  2060.         w = newintobject((long)e.u.command);
  2061.         break;
  2062.     case WE_DRAW:
  2063.         w = makerect(e.u.area.left, e.u.area.top,
  2064.                 e.u.area.right, e.u.area.bottom);
  2065.         break;
  2066.     case WE_MOUSE_DOWN:
  2067.     case WE_MOUSE_MOVE:
  2068.     case WE_MOUSE_UP:
  2069.         w = mkvalue("((ii)iii)",
  2070.                 e.u.where.h, e.u.where.v,
  2071.                 e.u.where.clicks,
  2072.                 e.u.where.button,
  2073.                 e.u.where.mask);
  2074.         break;
  2075.     case WE_MENU:
  2076.         if (e.u.m.id >= IDOFFSET && e.u.m.id < IDOFFSET+MAXNMENU &&
  2077.                 menulist[e.u.m.id - IDOFFSET] != NULL)
  2078.             w = mkvalue("(Oi)",
  2079.                     menulist[e.u.m.id - IDOFFSET], e.u.m.item);
  2080.         else {
  2081.             /* Ghost menu event.
  2082.                Can occur only on the Mac if another part
  2083.                of the aplication has installed a menu;
  2084.                like the THINK C console library. */
  2085.             DECREF(v);
  2086.             goto again;
  2087.         }
  2088.         break;
  2089.     case WE_KEY:
  2090.         w = mkvalue("(ii)", e.u.key.code, e.u.key.mask);
  2091.         break;
  2092.     case WE_LOST_SEL:
  2093.         w = newintobject((long)e.u.sel);
  2094.         break;
  2095.     default:
  2096.         w = None;
  2097.         INCREF(w);
  2098.         break;
  2099.     }
  2100.     if (w == NULL) {
  2101.         DECREF(v);
  2102.         return NULL;
  2103.     }
  2104.     u = mkvalue("(iOO)", e.type, v, w);
  2105.     XDECREF(v);
  2106.     XDECREF(w);
  2107.     return u;
  2108. }
  2109.  
  2110. static object *
  2111. stdwin_getevent(sw, args)
  2112.     object *sw;
  2113.     object *args;
  2114. {
  2115.     return stdwin_get_poll_event(0, args);
  2116. }
  2117.  
  2118. static object *
  2119. stdwin_pollevent(sw, args)
  2120.     object *sw;
  2121.     object *args;
  2122. {
  2123.     return stdwin_get_poll_event(1, args);
  2124. }
  2125.  
  2126. static object *
  2127. stdwin_setdefwinpos(sw, args)
  2128.     object *sw;
  2129.     object *args;
  2130. {
  2131.     int a[2];
  2132.     if (!getpointarg(args, a))
  2133.         return NULL;
  2134.     wsetdefwinpos(a[0], a[1]);
  2135.     INCREF(None);
  2136.     return None;
  2137. }
  2138.  
  2139. static object *
  2140. stdwin_setdefwinsize(sw, args)
  2141.     object *sw;
  2142.     object *args;
  2143. {
  2144.     int a[2];
  2145.     if (!getpointarg(args, a))
  2146.         return NULL;
  2147.     wsetdefwinsize(a[0], a[1]);
  2148.     INCREF(None);
  2149.     return None;
  2150. }
  2151.  
  2152. static object *
  2153. stdwin_setdefscrollbars(sw, args)
  2154.     object *sw;
  2155.     object *args;
  2156. {
  2157.     int a[2];
  2158.     if (!getpointarg(args, a))
  2159.         return NULL;
  2160.     wsetdefscrollbars(a[0], a[1]);
  2161.     INCREF(None);
  2162.     return None;
  2163. }
  2164.  
  2165. static object *
  2166. stdwin_getdefwinpos(self, args)
  2167.     object *self;
  2168.     object *args;
  2169. {
  2170.     int h, v;
  2171.     if (!getnoarg(args))
  2172.         return NULL;
  2173.     wgetdefwinpos(&h, &v);
  2174.     return makepoint(h, v);
  2175. }
  2176.  
  2177. static object *
  2178. stdwin_getdefwinsize(self, args)
  2179.     object *self;
  2180.     object *args;
  2181. {
  2182.     int width, height;
  2183.     if (!getnoarg(args))
  2184.         return NULL;
  2185.     wgetdefwinsize(&width, &height);
  2186.     return makepoint(width, height);
  2187. }
  2188.  
  2189. static object *
  2190. stdwin_getdefscrollbars(self, args)
  2191.     object *self;
  2192.     object *args;
  2193. {
  2194.     int h, v;
  2195.     if (!getnoarg(args))
  2196.         return NULL;
  2197.     wgetdefscrollbars(&h, &v);
  2198.     return makepoint(h, v);
  2199. }
  2200.  
  2201. static object *
  2202. stdwin_menucreate(self, args)
  2203.     object *self;
  2204.     object *args;
  2205. {
  2206.     char *title;
  2207.     if (!getstrarg(args, &title))
  2208.         return NULL;
  2209.     wmenusetdeflocal(0);
  2210.     return (object *)newmenuobject(title);
  2211. }
  2212.  
  2213. static object *
  2214. stdwin_askfile(self, args)
  2215.     object *self;
  2216.     object *args;
  2217. {
  2218.     char *prompt, *dflt;
  2219.     int new, ret;
  2220.     char buf[256];
  2221.     if (!getargs(args, "(ssi)", &prompt, &dflt, &new))
  2222.         return NULL;
  2223.     strncpy(buf, dflt, sizeof buf);
  2224.     buf[sizeof buf - 1] = '\0';
  2225.     BGN_STDWIN
  2226.     ret = waskfile(prompt, buf, sizeof buf, new);
  2227.     END_STDWIN
  2228.     if (!ret) {
  2229.         err_set(KeyboardInterrupt);
  2230.         return NULL;
  2231.     }
  2232.     return newstringobject(buf);
  2233. }
  2234.  
  2235. static object *
  2236. stdwin_askync(self, args)
  2237.     object *self;
  2238.     object *args;
  2239. {
  2240.     char *prompt;
  2241.     int new, ret;
  2242.     if (!getargs(args, "(si)", &prompt, &new))
  2243.         return NULL;
  2244.     BGN_STDWIN
  2245.     ret = waskync(prompt, new);
  2246.     END_STDWIN
  2247.     if (ret < 0) {
  2248.         err_set(KeyboardInterrupt);
  2249.         return NULL;
  2250.     }
  2251.     return newintobject((long)ret);
  2252. }
  2253.  
  2254. static object *
  2255. stdwin_askstr(self, args)
  2256.     object *self;
  2257.     object *args;
  2258. {
  2259.     char *prompt, *dflt;
  2260.     int ret;
  2261.     char buf[256];
  2262.     if (!getargs(args, "(ss)", &prompt, &dflt))
  2263.         return NULL;
  2264.     strncpy(buf, dflt, sizeof buf);
  2265.     buf[sizeof buf - 1] = '\0';
  2266.     BGN_STDWIN
  2267.     ret = waskstr(prompt, buf, sizeof buf);
  2268.     END_STDWIN
  2269.     if (!ret) {
  2270.         err_set(KeyboardInterrupt);
  2271.         return NULL;
  2272.     }
  2273.     return newstringobject(buf);
  2274. }
  2275.  
  2276. static object *
  2277. stdwin_message(self, args)
  2278.     object *self;
  2279.     object *args;
  2280. {
  2281.     char *msg;
  2282.     if (!getstrarg(args, &msg))
  2283.         return NULL;
  2284.     BGN_STDWIN
  2285.     wmessage(msg);
  2286.     END_STDWIN
  2287.     INCREF(None);
  2288.     return None;
  2289. }
  2290.  
  2291. static object *
  2292. stdwin_fleep(self, args)
  2293.     object *self;
  2294.     object *args;
  2295. {
  2296.     if (!getnoarg(args))
  2297.         return NULL;
  2298.     wfleep();
  2299.     INCREF(None);
  2300.     return None;
  2301. }
  2302.  
  2303. static object *
  2304. stdwin_setcutbuffer(self, args)
  2305.     object *self;
  2306.     object *args;
  2307. {
  2308.     int i, size;
  2309.     char *str;
  2310.     if (!getargs(args, "(is#)", &i, &str, &size))
  2311.         return NULL;
  2312.     wsetcutbuffer(i, str, size);
  2313.     INCREF(None);
  2314.     return None;
  2315. }
  2316.  
  2317. static object *
  2318. stdwin_getactive(self, args)
  2319.     object *self;
  2320.     object *args;
  2321. {
  2322.     return window2object(wgetactive());
  2323. }
  2324.  
  2325. static object *
  2326. stdwin_getcutbuffer(self, args)
  2327.     object *self;
  2328.     object *args;
  2329. {
  2330.     int i;
  2331.     char *str;
  2332.     int len;
  2333.     if (!getintarg(args, &i))
  2334.         return NULL;
  2335.     str = wgetcutbuffer(i, &len);
  2336.     if (str == NULL) {
  2337.         str = "";
  2338.         len = 0;
  2339.     }
  2340.     return newsizedstringobject(str, len);
  2341. }
  2342.  
  2343. static object *
  2344. stdwin_rotatecutbuffers(self, args)
  2345.     object *self;
  2346.     object *args;
  2347. {
  2348.     int i;
  2349.     if (!getintarg(args, &i))
  2350.         return NULL;
  2351.     wrotatecutbuffers(i);
  2352.     INCREF(None);
  2353.     return None;
  2354. }
  2355.  
  2356. static object *
  2357. stdwin_getselection(self, args)
  2358.     object *self;
  2359.     object *args;
  2360. {
  2361.     int sel;
  2362.     char *data;
  2363.     int len;
  2364.     if (!getintarg(args, &sel))
  2365.         return NULL;
  2366.     data = wgetselection(sel, &len);
  2367.     if (data == NULL) {
  2368.         data = "";
  2369.         len = 0;
  2370.     }
  2371.     return newsizedstringobject(data, len);
  2372. }
  2373.  
  2374. static object *
  2375. stdwin_resetselection(self, args)
  2376.     object *self;
  2377.     object *args;
  2378. {
  2379.     int sel;
  2380.     if (!getintarg(args, &sel))
  2381.         return NULL;
  2382.     wresetselection(sel);
  2383.     INCREF(None);
  2384.     return None;
  2385. }
  2386.  
  2387. static object *
  2388. stdwin_fetchcolor(self, args)
  2389.     object *self;
  2390.     object *args;
  2391. {
  2392.     char *colorname;
  2393.     COLOR color;
  2394.     if (!getstrarg(args, &colorname))
  2395.         return NULL;
  2396.     color = wfetchcolor(colorname);
  2397. #ifdef BADCOLOR
  2398.     if (color == BADCOLOR) {
  2399.         err_setstr(StdwinError, "color name not found");
  2400.         return NULL;
  2401.     }
  2402. #endif
  2403.     return newintobject((long)color);
  2404. }
  2405.  
  2406. static object *
  2407. stdwin_getscrsize(self, args)
  2408.     object *self;
  2409.     object *args;
  2410. {
  2411.     int width, height;
  2412.     if (!getnoarg(args))
  2413.         return NULL;
  2414.     wgetscrsize(&width, &height);
  2415.     return makepoint(width, height);
  2416. }
  2417.  
  2418. static object *
  2419. stdwin_getscrmm(self, args)
  2420.     object *self;
  2421.     object *args;
  2422. {
  2423.     int width, height;
  2424.     if (!getnoarg(args))
  2425.         return NULL;
  2426.     wgetscrmm(&width, &height);
  2427.     return makepoint(width, height);
  2428. }
  2429.  
  2430. #ifdef unix
  2431. static object *
  2432. stdwin_connectionnumber(self, args)
  2433.     object *self;
  2434.     object *args;
  2435. {
  2436.     if (!getnoarg(args))
  2437.         return NULL;
  2438.     return newintobject((long) wconnectionnumber());
  2439. }
  2440. #endif
  2441.  
  2442. static object *
  2443. stdwin_listfontnames(self, args)
  2444.     object *self;
  2445.     object *args;
  2446. {
  2447.     char *pattern;
  2448.     char **fontnames;
  2449.     int count;
  2450.     object *list;
  2451.     if (!getargs(args, "z", &pattern))
  2452.         return NULL;
  2453.     fontnames = wlistfontnames(pattern, &count);
  2454.     list = newlistobject(count);
  2455.     if (list != NULL) {
  2456.         int i;
  2457.         for (i = 0; i < count; i++) {
  2458.             object *v = newstringobject(fontnames[i]);
  2459.             if (v == NULL) {
  2460.                 DECREF(list);
  2461.                 list = NULL;
  2462.                 break;
  2463.             }
  2464.             setlistitem(list, i, v);
  2465.         }
  2466.     }
  2467.     return list;
  2468. }
  2469.  
  2470. #ifdef HAVE_BITMAPS
  2471. static object *
  2472. stdwin_newbitmap(self, args)
  2473.     object *self;
  2474.     object *args;
  2475. {
  2476.     int width, height;
  2477.     bitmapobject *bp;
  2478.     if (!getargs(args, "(ii)", &width, &height))
  2479.         return NULL;
  2480.     return (object *)newbitmapobject(width, height);
  2481. }
  2482. #endif
  2483.  
  2484. static struct methodlist stdwin_methods[] = {
  2485.     {"askfile",        stdwin_askfile},
  2486.     {"askstr",        stdwin_askstr},
  2487.     {"askync",        stdwin_askync},
  2488.     {"done",        stdwin_done},
  2489.     {"fetchcolor",        stdwin_fetchcolor},
  2490. #ifdef unix
  2491.     {"fileno",        stdwin_connectionnumber},
  2492.     {"connectionnumber",    stdwin_connectionnumber},
  2493. #endif
  2494.     {"fleep",        stdwin_fleep},
  2495.     {"getactive",        stdwin_getactive},
  2496.     {"getcutbuffer",    stdwin_getcutbuffer},
  2497.     {"getdefscrollbars",    stdwin_getdefscrollbars},
  2498.     {"getdefwinpos",    stdwin_getdefwinpos},
  2499.     {"getdefwinsize",    stdwin_getdefwinsize},
  2500.     {"getevent",        stdwin_getevent},
  2501.     {"getscrmm",        stdwin_getscrmm},
  2502.     {"getscrsize",        stdwin_getscrsize},
  2503.     {"getselection",    stdwin_getselection},
  2504.     {"listfontnames",    stdwin_listfontnames},
  2505.     {"menucreate",        stdwin_menucreate},
  2506.     {"message",        stdwin_message},
  2507. #ifdef HAVE_BITMAPS
  2508.     {"newbitmap",        stdwin_newbitmap},
  2509. #endif
  2510.     {"open",        stdwin_open},
  2511.     {"pollevent",        stdwin_pollevent},
  2512.     {"resetselection",    stdwin_resetselection},
  2513.     {"rotatecutbuffers",    stdwin_rotatecutbuffers},
  2514.     {"setcutbuffer",    stdwin_setcutbuffer},
  2515.     {"setdefscrollbars",    stdwin_setdefscrollbars},
  2516.     {"setdefwinpos",    stdwin_setdefwinpos},
  2517.     {"setdefwinsize",    stdwin_setdefwinsize},
  2518.     
  2519.     /* Text measuring methods borrow code from drawing objects: */
  2520.     {"baseline",        (method)drawing_baseline},
  2521.     {"lineheight",        (method)drawing_lineheight},
  2522.     {"textbreak",        (method)drawing_textbreak},
  2523.     {"textwidth",        (method)drawing_textwidth},
  2524.  
  2525.     /* Same for font setting methods: */
  2526.     {"setfont",        (method)drawing_setfont},
  2527.  
  2528.     /* Same for color setting/getting methods: */
  2529.     {"getbgcolor",        (method)drawing_getbgcolor},
  2530.     {"getfgcolor",        (method)drawing_getfgcolor},
  2531.     {"setbgcolor",        (method)drawing_setbgcolor},
  2532.     {"setfgcolor",        (method)drawing_setfgcolor},
  2533.  
  2534.     {NULL,            NULL}        /* sentinel */
  2535. };
  2536.  
  2537. #ifndef macintosh
  2538. static int
  2539. checkstringlist(args, ps, pn)
  2540.     object *args;
  2541.     char ***ps;
  2542.     int *pn;
  2543. {
  2544.     int i, n;
  2545.     char **s;
  2546.     if (!is_listobject(args)) {
  2547.         err_setstr(TypeError, "list of strings expected");
  2548.         return 0;
  2549.     }
  2550.     n = getlistsize(args);
  2551.     s = NEW(char *, n+1);
  2552.     if (s == NULL) {
  2553.         err_nomem();
  2554.         return 0;
  2555.     }
  2556.     for (i = 0; i < n; i++) {
  2557.         object *item = getlistitem(args, i);
  2558.         if (!is_stringobject(item)) {
  2559.             err_setstr(TypeError, "list of strings expected");
  2560.             return 0;
  2561.         }
  2562.         s[i] = getstringvalue(item);
  2563.     }
  2564.     s[n] = NULL; /* In case caller wants a NULL-terminated list */
  2565.     *ps = s;
  2566.     *pn = n;
  2567.     return 1;
  2568. }
  2569.  
  2570. static int
  2571. putbackstringlist(list, s, n)
  2572.     object *list;
  2573.     char **s;
  2574.     int n;
  2575. {
  2576.     int oldsize = getlistsize(list);
  2577.     object *newlist;
  2578.     int i;
  2579.     if (n == oldsize)
  2580.         return 1;
  2581.     newlist = newlistobject(n);
  2582.     for (i = 0; i < n && newlist != NULL; i++) {
  2583.         object *item = newstringobject(s[i]);
  2584.         if (item == NULL) {
  2585.             DECREF(newlist);
  2586.             newlist = NULL;
  2587.         }
  2588.         else
  2589.             setlistitem(newlist, i, item);
  2590.     }
  2591.     if (newlist == NULL)
  2592.         return 0;
  2593.     (*list->ob_type->tp_as_sequence->sq_ass_slice)
  2594.         (list, 0, oldsize, newlist);
  2595.     DECREF(newlist);
  2596.     return 1;
  2597. }
  2598. #endif /* macintosh */
  2599.  
  2600. void
  2601. initstdwin()
  2602. {
  2603.     object *m, *d;
  2604.     static int inited = 0;
  2605.  
  2606.     if (!inited) {
  2607. #ifdef macintosh
  2608.         winit();
  2609.         PyMac_DoYieldEnabled = 0;
  2610. #else
  2611.         char buf[1000];
  2612.         int argc = 0;
  2613.         char **argv = NULL;
  2614.         object *sys_argv = sysget("argv");
  2615.         if (sys_argv != NULL) {
  2616.             if (!checkstringlist(sys_argv, &argv, &argc))
  2617.                 err_clear();
  2618.         }
  2619.         if (argc > 0) {
  2620.             /* If argv[0] has a ".py" suffix, remove the suffix */
  2621.             char *p = strrchr(argv[0], '.');
  2622.             if (p != NULL && strcmp(p, ".py") == 0) {
  2623.                 int n = p - argv[0];
  2624.                 if (n >= sizeof(buf))
  2625.                     n = sizeof(buf)-1;
  2626.                 strncpy(buf, argv[0], n);
  2627.                 buf[n] = '\0';
  2628.                 argv[0] = buf;
  2629.             }
  2630.         }
  2631.         winitargs(&argc, &argv);
  2632.         if (argv != NULL) {
  2633.             if (!putbackstringlist(sys_argv, argv, argc))
  2634.                 err_clear();
  2635.         }
  2636. #endif
  2637.         inited = 1;
  2638.     }
  2639.     m = initmodule("stdwin", stdwin_methods);
  2640.     d = getmoduledict(m);
  2641.     
  2642.     /* Initialize stdwin.error exception */
  2643.     StdwinError = newstringobject("stdwin.error");
  2644.     if (StdwinError == NULL || dictinsert(d, "error", StdwinError) != 0)
  2645.         fatal("can't define stdwin.error");
  2646. #ifdef WITH_THREAD
  2647.     StdwinLock = allocate_lock();
  2648.     if (StdwinLock == NULL)
  2649.         fatal("can't allocate stdwin lock");
  2650. #endif
  2651. }
  2652.